1. Field of the Invention
The present invention relates generally to mixed signal distributed arithmetic, and more specifically to a reconfigurable mixed-signal very-large-scale integration (VLSI) implementation of distributed arithmetic.
2. Description of Related Art
The battery lifetime of portable electronics has become a major design concern as greater functionality is incorporated into portable electronic devices. The shrinking power budget of modern portable devices requires the use of low-power circuits for signal processing applications. These devices include, but are not limited to, flash memory and hard disk based audio players. The data, or media, in these devices is generally stored in a digital format but the output is still synthesized as an analog signal. The signal processing functions employed in such devices may include finite impulse response (FIR) filters, discrete cosine transforms (DCTs), and discrete Fourier transforms (DFTs), which have traditionally been performed using digital signal processing (DSP). DSP implementations typically make use of multiply-and-accumulate (MAC) units for the calculation of these operations, and as a result the computation time increases linearly as the length of the input vector grows.
In many other applications, the input data is analog not digital while the output remains analog. Often, the processing for these applications do not require digital signal processing components therefore do not require the analog input to be converted into a digital signal. If such a conversion did occur, then this would use unnecessary power. Or, the processing for these applications occurred at a point where a digital-to-analog signal processing component would not be appropriate. For such applications, an analog-to-analog signal processing component would be preferred. Examples of these applications include but are not limited to signal processing for sensor networks, wireless communications, audio systems, hearing aids, and video systems.
Distributed arithmetic (DA) is an efficient way to compute an inner product, which is a common feature of the FIR filter, DCT, and DFT functions. DA computes an inner product in a fixed number of cycles, which is determined by the precision of the input data. In a traditional DA implementation, the inner product operation,
                              y          ⁡                      [            n            ]                          =                              ∑                          i              =              0                                      K              -              1                                ⁢                                    w              i                        ⁢                          x              ⁡                              [                                  n                  -                  i                                ]                                                                        (        1        )            is done as follows. Let the input signal samples be represented as B-bit 2's complement binary numbers,
                                          x            ⁡                          [                              n                -                i                            ]                                =                                    -                              b                                  i                  ⁢                                                                          ⁢                  0                                                      +                                          ∑                                  i                  =                  1                                                  B                  -                  1                                            ⁢                                                b                  il                                ⁢                                  2                                      -                    l                                                                                      ,                                  ⁢                  i          =          0                ,        …        ⁢                                  ,                  K          -          1                ,                            (        2        )            where bil is the lth bit in the 2's complement representation of x[n−i]. Substituting equation (2) into equation (1) and swapping the order of the summations yields
                              y          ⁡                      [            n            ]                          =                              -                          [                                                ∑                                      i                    =                    0                                                        K                    -                    1                                                  ⁢                                                      b                                          i                      ⁢                                                                                          ⁢                      0                                                        ⁢                                      w                    i                                                              ]                                +                                    ∑                              l                =                1                                            B                -                1                                      ⁢                                          [                                                      ∑                                          i                      =                      0                                                              K                      -                      1                                                        ⁢                                                            b                      il                                        ⁢                                          w                      i                                                                      ]                            ⁢                                                2                                      -                    l                                                  .                                                                        (        3        )            For a given set of wi (i=0, . . . , K−1), the terms in the square braces may take only one of 2K possible values which are stored in a lookup table (LUT). The DA computation is then an implementation of equation (3). Another way to interpret equation (1) is to represent the coefficients as B-bit 2's complement binary numbers,
                                          w            i                    =                                    -                              b                                  i                  ⁢                                                                          ⁢                  0                                                      +                                          ∑                                  l                  =                  1                                                  B                  -                  1                                            ⁢                                                b                  il                                ⁢                                  2                                      -                    l                                                                                      ,                                  ⁢                  i          =          0                ,        …        ⁢                                  ,                  K          -          1                ,                            (        4        )            where bil is the lth bit in the 2's complement representation of wi. Substituting equation (4) into equation (1) and swapping the order of the summations yields
                              y          ⁡                      [            n            ]                          =                              -                          [                                                ∑                                      i                    =                    0                                                        K                    -                    1                                                  ⁢                                                      b                                          i                      ⁢                                                                                          ⁢                      0                                                        ⁢                                      x                    ⁡                                          [                                              n                        -                        i                                            ]                                                                                  ]                                +                                    ∑                              l                =                1                                            B                -                1                                      ⁢                                          [                                                      ∑                                          i                      =                      0                                                              K                      -                      1                                                        ⁢                                                            b                      il                                        ⁢                                          x                      ⁡                                              [                                                  n                          -                          i                                                ]                                                                                            ]                            ⁢                                                2                                      -                    l                                                  .                                                                        (        5        )            Now the LUT contains all possible combination sums of the input signal samples {x[n], x[n−1], . . . , x[n−K+1]}.
DA is computationally more efficient than MAC-based approach when the input vector length is large. However, the trade-off for the computational efficiency is the increased power consumption and area usage due to the use of a large memory. What is needed therefore is a mixed signal circuit implementation for optimized DA performance, power consumption, and area usage.